home *** CD-ROM | disk | FTP | other *** search
/ Compendium Deluxe 2 / LSD and 17bit Compendium Deluxe - Volume II.iso / a / prog / misc / interfaces3_5.lha / Interfaces / Utility.mod < prev    next >
Text File  |  1994-11-06  |  23KB  |  564 lines
  1. (*
  2. (*
  3. **  Amiga Oberon Interface Module:
  4. **  $VER: Utility.mod 40.15 (6.11.94) Oberon 3.5
  5. **
  6. **   © 1993 by Fridtjof Siebert
  7. **   updated for V39, V40 by hartmut Goebel
  8. *)
  9. *)
  10.  
  11. MODULE Utility;
  12.  
  13. (* !!! ATTENTION !!!
  14.  * Before you use any routine of this library, you'll have to check
  15.  * Utility.base # NIL.
  16.  *)
  17.  
  18. IMPORT e * := Exec,
  19.        SYSTEM;
  20.  
  21. CONST
  22.   utilityName * = "utility.library";
  23.  
  24. (*****************************************************************************)
  25. TYPE
  26.   ClockDataPtr * = UNTRACED POINTER TO ClockData;
  27.   HookPtr * = UNTRACED POINTER TO Hook;
  28.  
  29.   ClockData * = STRUCT
  30.     sec  * : INTEGER;
  31.     min  * : INTEGER;
  32.     hour * : INTEGER;
  33.     mday * : INTEGER;
  34.     month* : INTEGER;
  35.     year * : INTEGER;
  36.     wday * : INTEGER;
  37.   END;
  38.  
  39.  
  40. (* Useful definition for casting function pointers:
  41.  * hook.h_entry    = (ASMHOOKFUNC)AsmFunction
  42.  * hook.h_SubEntry = (HOOKFUNC)AFunction
  43.  *)
  44.   HookFunc * = PROCEDURE(hook: HookPtr; object: e.APTR; message: e.APTR): e.APTR;
  45.   AsmHookFunc * = PROCEDURE(hook{8}: HookPtr;
  46.                             object{10}: e.APTR;
  47.                             message{9}: e.APTR): e.APTR; (* assembler entry point *)
  48.  
  49.  
  50. (* new standard hook structure *)
  51.   Hook * = STRUCT (minNode * : e.MinNode)
  52.     entry    *: AsmHookFunc;  (* assembler entry point *)
  53.     subEntry *: HookFunc;     (* often HLL entry point *)
  54.     data     *: e.APTR;       (* owner specific        *)
  55.   END;
  56.  
  57. (* ---- Default Hook-Dispatcher ---- *)
  58. PROCEDURE HookEntry*(hook{8}: HookPtr;               (* $SaveRegs+ $StackChk- *)
  59.                      object{10}: e.APTR;
  60.                      message{9}: e.APTR): e.APTR;
  61. (*
  62.  * Calls haook.subEntry. The contents of A5 have to be stored in hook.data,
  63.  * else A5 would not be set correctly.
  64.  *)
  65.  
  66. BEGIN
  67.   SYSTEM.SETREG(13,hook.data);
  68.   RETURN hook.subEntry(hook,object,message);
  69. END HookEntry;
  70.  
  71.  
  72. PROCEDURE InitHook* (hook{8}: HookPtr; entry{9}: HookFunc);
  73. BEGIN
  74.   hook.entry := HookEntry;     (* $NilChk- -- one check is enough *)
  75.   hook.subEntry := entry;
  76.   hook.data := SYSTEM.REG(13); (* $NilChk= *)
  77. END InitHook;
  78.  
  79. (*
  80.  * Hook calling conventions:
  81.  *
  82.  * The function pointed to by Hook.h_Entry is called with the following
  83.  * parameters:
  84.  *
  85.  *    A0 - pointer to hook data structure itself
  86.  *    A1 - pointer to parameter structure ("message")
  87.  *    A2 - Hook specific address data ("object")
  88.  *
  89.  * Control will be passed to the routine h_Entry.  For many
  90.  * High-Level Languages (HLL), this will be an assembly language
  91.  * stub which pushes registers on the stack, does other setup,
  92.  * and then calls the function at h_SubEntry.
  93.  *
  94.  * The standard C receiving code is:
  95.  *
  96.  *    HookFunc(struct Hook *hook, APTR object, APTR message)
  97.  *
  98.  * Note that register natural order differs from this convention for C
  99.  * parameter order, which is A0,A2,A1.
  100.  *
  101.  * The assembly language stub for "vanilla" C parameter conventions
  102.  * could be:
  103.  *
  104.  * _hookEntry:
  105.  *    move.l  a1,-(sp)                ; push message packet pointer
  106.  *    move.l  a2,-(sp)                ; push object pointer
  107.  *    move.l  a0,-(sp)                ; push hook pointer
  108.  *    move.l  h_SubEntry(a0),a0       ; fetch C entry point ...
  109.  *    jsr     (a0)                    ; ... and call it
  110.  *    lea     12(sp),sp               ; fix stack
  111.  *    rts
  112.  *
  113.  * With this function as your interface stub, you can write a Hook setup
  114.  * function as:
  115.  *
  116.  * InitHook(struct Hook *hook, ULONG ( *c_function)(), APTR userdata)
  117.  * {
  118.  * ULONG ( *hookEntry)();
  119.  *
  120.  *     hook->h_Entry  = hookEntry;
  121.  *     hook->h_SubEntry = c_function;
  122.  *     hook->h_Data   = userdata;
  123.  * }
  124.  *
  125.  * With a compiler capable of registerized parameters, such as SAS C, you
  126.  * can put the C function in the h_Entry field directly. For example, for
  127.  * SAS C:
  128.  *
  129.  *   ULONG __saveds __asm HookFunc(register __a0 struct Hook *hook,
  130.  *                               register __a2 APTR         object,
  131.  *                               register __a1 APTR         message);
  132.  *
  133.  *)
  134.  
  135. (* ======================================================================= *)
  136. (* ==== TagItem ========================================================== *)
  137. (* ======================================================================= *)
  138. (* Tags are a general mechanism of extensible data arrays for parameter
  139.  * specification and property inquiry. In practice, tags are used in arrays,
  140.  * or chain of arrays.
  141.  *
  142.  *)
  143.  
  144. TYPE
  145.   Tag   * = e.APTR;
  146.   TagID * = LONGINT;
  147.  
  148.   TagItem * = STRUCT
  149.     tag  * : TagID; (* identifies the type of data *)
  150.     data * : Tag;   (* type-specific data          *)
  151.   END;
  152.  
  153.   TagItemPtr * = UNTRACED POINTER TO TagItem;
  154.   TagListPtr * = UNTRACED POINTER TO ARRAY MAX(INTEGER) OF TagItem;
  155.  
  156. (* Types for 'ARRAY OF TagItem'-Parameters: *)
  157.  
  158.   Tags1  * = ARRAY  1 OF TagItem;
  159.   Tags2  * = ARRAY  2 OF TagItem;
  160.   Tags3  * = ARRAY  3 OF TagItem;
  161.   Tags4  * = ARRAY  4 OF TagItem;
  162.   Tags5  * = ARRAY  5 OF TagItem;
  163.   Tags6  * = ARRAY  6 OF TagItem;
  164.   Tags7  * = ARRAY  7 OF TagItem;
  165.   Tags8  * = ARRAY  8 OF TagItem;
  166.   Tags9  * = ARRAY  9 OF TagItem;
  167.   Tags10 * = ARRAY 10 OF TagItem;
  168.   Tags11 * = ARRAY 11 OF TagItem;
  169.   Tags12 * = ARRAY 12 OF TagItem;
  170.   Tags13 * = ARRAY 13 OF TagItem;
  171.   Tags14 * = ARRAY 14 OF TagItem;
  172.   Tags15 * = ARRAY 15 OF TagItem;
  173.   Tags16 * = ARRAY 16 OF TagItem;
  174.   Tags17 * = ARRAY 17 OF TagItem;
  175.   Tags18 * = ARRAY 18 OF TagItem;
  176.   Tags19 * = ARRAY 19 OF TagItem;
  177.   Tags20 * = ARRAY 20 OF TagItem;
  178.   Tags21 * = ARRAY 21 OF TagItem;
  179.   Tags22 * = ARRAY 22 OF TagItem;
  180.   Tags23 * = ARRAY 23 OF TagItem;
  181.   Tags24 * = ARRAY 24 OF TagItem;
  182.   Tags25 * = ARRAY 25 OF TagItem;
  183.   Tags26 * = ARRAY 26 OF TagItem;
  184.   Tags27 * = ARRAY 27 OF TagItem;
  185.   Tags28 * = ARRAY 28 OF TagItem;
  186.   Tags29 * = ARRAY 29 OF TagItem;
  187.  
  188. CONST
  189. (*****************************************************************************)
  190.  
  191. (* constants for Tag.ti_Tag, control tag values *)
  192.   done   * = 0;    (* terminates array of TagItems. ti_Data unused *)
  193.   end    * = done; (* synonym for TAG_DONE                         *)
  194.   ignore * = 1;    (* ignore this item, not end of array           *)
  195.   more   * = 2;    (* ti_Data is pointer to another array of TagItems
  196.                     * note that this tag terminates the current array
  197.                     *)
  198.   skip   * = 3;    (* skip this and the next TagItem.data items    *)
  199.  
  200. (* differentiates user tags from system tags*)
  201.   user   * = 80000000H;
  202.  
  203. (* If the TAG_USER bit is set in a tag number, it tells utility.library that
  204.  * the tag is not a control tag (like TAG_DONE, TAG_IGNORE, TAG_MORE) and is
  205.  * instead an application tag. "USER" means a client of utility.library in
  206.  * general, including system code like Intuition or ASL, it has nothing to do
  207.  * with user code.
  208.  *)
  209.  
  210. (*****************************************************************************)
  211.  
  212. (* Tag filter logic specifiers for use with FilterTagItems() *)
  213.   filterAnd * = 0;     (* exclude everything but filter hits   *)
  214.   filterNot * = 1;     (* exclude only filter hits             *)
  215.  
  216. (*****************************************************************************)
  217.  
  218. (* Mapping types for use with MapTags() *)
  219.   removeNotFound * = 0;        (* remove tags that aren't in mapList *)
  220.   keepNotFound   * = 1;        (* keep tags that aren't in mapList   *)
  221.  
  222. TYPE
  223. (*****************************************************************************)
  224.  
  225. (* The named object structure
  226.  *)
  227.   NamedObjectPtr * = UNTRACED POINTER TO NamedObject;
  228.   NamedObject * = STRUCT
  229.     object * : e.APTR;     (* Your pointer, for whatever you want *)
  230.   END;
  231.  
  232. (* Tags for AllocNamedObject() *)
  233. CONST
  234.   nameSpace  * =   4000;    (* tag to define namespace      *)
  235.   userSpace  * =   4001;    (* tag to define userspace      *)
  236.   priority   * =   4002;    (* tag to define priority       *)
  237.   flags      * =   4003;    (* tag to define flags          *)
  238.  
  239. (* Flags for tag ANO_FLAGS *)
  240.   noDups    * =   0;       (* Default allow duplicates *)
  241.   case      * =   1;       (* Default to caseless... *)
  242.  
  243. (*****************************************************************************)
  244.  
  245.  
  246. (* PackTable definition:
  247.  *
  248.  * The PackTable is a simple array of LONGWORDS that are evaluated by
  249.  * PackStructureTags() and UnpackStructureTags().
  250.  *
  251.  * The table contains compressed information such as the tag offset from
  252.  * the base tag. The tag offset has a limited range so the base tag is
  253.  * defined in the first longword.
  254.  *
  255.  * After the first longword, the fields look as follows:
  256.  *
  257.  *      +--------- 1 = signed, 0 = unsigned (for bits, 1=inverted boolean)
  258.  *      |
  259.  *      |  +------ 00 = Pack/Unpack, 10 = Pack, 01 = Unpack, 11 = special
  260.  *      | / \
  261.  *      | | |  +-- 00 = Byte, 01 = Word, 10 = Long, 11 = Bit
  262.  *      | | | / \
  263.  *      | | | | | /----- For bit operations: 1 = TAG_EXISTS is TRUE
  264.  *      | | | | | |
  265.  *      | | | | | | /-------------------- Tag offset from base tag value
  266.  *      | | | | | | |                 \
  267.  *      m n n o o p q q q q q q q q q q r r r s s s s s s s s s s s s s
  268.  *                                      \   | |               |
  269.  *      Bit offset (for bit operations) ----/ |               |
  270.  *                                            \                       |
  271.  *      Offset into data structure -----------------------------------/
  272.  *
  273.  * A -1 longword signifies that the next longword will be a new base tag
  274.  *
  275.  * A 0 longword signifies that it is the end of the pack table.
  276.  *
  277.  * What this implies is that there are only 13-bits of address offset
  278.  * and 10 bits for tag offsets from the base tag.  For most uses this
  279.  * should be enough, but when this is not, either multiple pack tables
  280.  * or a pack table with extra base tags would be able to do the trick.
  281.  * The goal here was to make the tables small and yet flexible enough to
  282.  * handle most cases.
  283.  *)
  284.  
  285.   signed * = 31;
  286.   unpack * = 30;    (* Note that these are active low... *)
  287.   pack   * = 29;    (* Note that these are active low... *)
  288.   exists * = 26;    (* Tag exists bit true flag hack...  *)
  289.  
  290. (*****************************************************************************)
  291.  
  292.  
  293.   ctrlPackUnpack * = 000000000H;
  294.   ctrlPackOnly   * = 040000000H;
  295.   ctrlUnpackOnly * = 020000000H;
  296.  
  297.   ctrlByte       * = 080000000H;
  298.   ctrlWord       * = 088000000H;
  299.   ctrlLong       * = 090000000H;
  300.  
  301.   ctrlUByte      * = 000000000H;
  302.   ctrlUWord      * = 008000000H;
  303.   ctrlULong      * = 010000000H;
  304.  
  305.   ctrlBit        * = 018000000H;
  306.   ctrlFlipBit    * = 098000000H;
  307.  
  308. (*****************************************************************************)
  309.  
  310. TYPE
  311.   UtilityBasePtr * = UNTRACED POINTER TO UtilityBase;
  312.   UtilityBase * = STRUCT (libNode * : e.Library)
  313.     language   * : SHORTINT;
  314.     reserved   * : SHORTINT;
  315.   END;
  316.  
  317. (******************************************************************************)
  318.  
  319. (*
  320.  * Sorry, but since Oberon has no precompiler (this is good) and thuth
  321.  * no macros like in 'C', you this PACK macros can not be translated to
  322.  * Oberon :-(. If you got an idea, how to solve this problen (e.g. you
  323.  * have written a pre-compiler ;-) please contact me:
  324.  * e-mail: interfaces@oberon.nbg.sub.org
  325.  * THANKS!
  326.  *)
  327.  
  328. (* Macros used by the next batch of macros below. Normally, you don't use
  329.  * this batch directly. Then again, some folks are wierd
  330.  *)
  331. (*
  332. #define PK_BITNUM1(flg) ((flg) == 0x01 ? 0 : (flg) == 0x02 ? 1 : (flg) == 0x04 ? 2 : (flg) == 0x08 ? 3 : (flg) == 0x10 ? 4 : (flg) == 0x20 ? 5 : (flg) == 0x40 ? 6 : 7)
  333. #define PK_BITNUM2(flg) ((flg < 0x100 ? PK_BITNUM1(flg) : 8+PK_BITNUM1(flg >> 8)))
  334. #define PK_BITNUM(flg) ((flg < 0x10000 ? PK_BITNUM2(flg) : 16+PK_BITNUM2(flg >> 16)))
  335. #define PK_WORDOFFSET(flg) ((flg) < 0x100 ? 1 : 0)
  336. #define PK_LONGOFFSET(flg) ((flg) < 0x100  ? 3 : (flg) < 0x10000 ? 2 : (flg) < 0x1000000 ? 1 : 0)
  337. #define PK_CALCOFFSET(type,field) ((ULONG)(&((struct type * )0)->field))
  338. *)
  339.  
  340. (*****************************************************************************)
  341.  
  342.  
  343. (* Some handy dandy macros to easily create pack tables
  344.  *
  345.  * Use PACK_STARTTABLE() at the start of a pack table. You pass it the
  346.  * base tag value that will be handled in the following chunk of the pack
  347.  * table.
  348.  *
  349.  * PACK_ENDTABLE() is used to mark the end of a pack table.
  350.  *
  351.  * PACK_NEWOFFSET() lets you change the base tag value used for subsequent
  352.  * entries in the table
  353.  *
  354.  * PACK_ENTRY() lets you define an entry in the pack table. You pass it the
  355.  * base tag value, the tag of interest, the type of the structure to use,
  356.  * the field name in the structure to affect and control bits (combinations of
  357.  * the various PKCTRL_XXX bits)
  358.  *
  359.  * PACK_BYTEBIT() lets you define a bit-control entry in the pack table. You
  360.  * pass it the same data as PACK_ENTRY, plus the flag bit pattern this tag
  361.  * affects. This macro should be used when the field being affected is byte
  362.  * sized.
  363.  *
  364.  * PACK_WORDBIT() lets you define a bit-control entry in the pack table. You
  365.  * pass it the same data as PACK_ENTRY, plus the flag bit pattern this tag
  366.  * affects. This macro should be used when the field being affected is word
  367.  * sized.
  368.  *
  369.  * PACK_LONGBIT() lets you define a bit-control entry in the pack table. You
  370.  * pass it the same data as PACK_ENTRY, plus the flag bit pattern this tag
  371.  * affects. This macro should be used when the field being affected is longword
  372.  * sized.
  373.  *
  374.  * EXAMPLE:
  375.  *
  376.  *    ULONG packTable[] =
  377.  *    {
  378.  *         PACK_STARTTABLE(GA_Dummy),
  379.  *         PACK_ENTRY(GA_Dummy,GA_Left,Gadget,LeftEdge,PKCTRL_WORD|PKCTRL_PACKUNPACK),
  380.  *         PACK_ENTRY(GA_Dummy,GA_Top,Gadget,TopEdge,PKCTRL_WORD|PKCTRL_PACKUNPACK),
  381.  *         PACK_ENTRY(GA_Dummy,GA_Width,Gadget,Width,PKCTRL_UWORD|PKCTRL_PACKUNPACK),
  382.  *         PACK_ENTRY(GA_Dummy,GA_Height,Gadget,Height,PKCTRL_UWORD|PKCTRL_PACKUNPACK),
  383.  *         PACK_WORDBIT(GA_Dummy,GA_RelVerify,Gadget,Activation,PKCTRL_BIT|PKCTRL_PACKUNPACK,GACT_RELVERIFY)
  384.  *         PACK_ENDTABLE
  385.  *    };
  386.  *)
  387. (*
  388. #define PACK_STARTTABLE(tagbase)                           (tagbase)
  389. #define PACK_NEWOFFSET(tagbase)                            (-1L),(tagbase)
  390. #define PACK_ENDTABLE                                      0
  391. #define PACK_ENTRY(tagbase,tag,type,field,control)         (control | ((tag-tagbase) << 16L) | PK_CALCOFFSET(type,field))
  392. #define PACK_BYTEBIT(tagbase,tag,type,field,control,flags) (control | ((tag-tagbase) << 16L) | PK_CALCOFFSET(type,field) | (PK_BITNUM(flags) << 13L))
  393. #define PACK_WORDBIT(tagbase,tag,type,field,control,flags) (control | ((tag-tagbase) << 16L) | (PK_CALCOFFSET(type,field)+PK_WORDOFFSET(flags)) | ((PK_BITNUM(flags)&7) << 13L))
  394. #define PACK_LONGBIT(tagbase,tag,type,field,control,flags) (control | ((tag-tagbase) << 16L) | (PK_CALCOFFSET(type,field)+PK_LONGOFFSET(flags)) | ((PK_BITNUM(flags)&7) << 13L))
  395.  *)
  396.  
  397. (*****************************************************************************)
  398.  
  399. VAR
  400.   base * : UtilityBasePtr;
  401.  
  402.  
  403. (* $OvflChk- $RangeChk- $StackChk- $NilChk- $ReturnChk- $CaseChk- *)
  404.  
  405.  
  406. (*--- functions in V36 or higher (Release 2.0) ---*)
  407.  
  408. (* Tag item functions *)
  409.  
  410. PROCEDURE FindTagItemA    *{base,- 30}(tagVar{0}      : TagID;
  411.                                        tagList{8}     : ARRAY OF TagItem): TagItemPtr;
  412. PROCEDURE FindTagItem     *{base,- 30}(tagVar{0}      : TagID;
  413.                                        tags{8}        : TagListPtr): TagItemPtr;
  414. PROCEDURE GetTagDataPA    *{base,- 36}(tagVal{0}      : TagID;
  415.                                        defaultValue{1}: e.APTR;
  416.                                        tagList{8}     : ARRAY OF TagItem): e.APTR;
  417. PROCEDURE GetTagDataA     *{base,- 36}(tagVal{0}      : TagID;
  418.                                        defaultValue{1}: LONGINT;
  419.                                        tagList{8}     : ARRAY OF TagItem): LONGINT;
  420. PROCEDURE GetTagDataP     *{base,- 36}(tagVal{0}      : TagID;
  421.                                        defaultValue{1}: e.APTR;
  422.                                        tags{8}        : TagListPtr): e.APTR;
  423. PROCEDURE GetTagData      *{base,- 36}(tagVal{0}      : TagID;
  424.                                        defaultValue{1}: LONGINT;
  425.                                        tags{8}        : TagListPtr): LONGINT;
  426. PROCEDURE PackBoolTagsA   *{base,- 42}(initialFlags{0}: LONGSET;
  427.                                        tagList{8}     : ARRAY OF TagItem;
  428.                                        boolMap{9}     : ARRAY OF TagItem): LONGSET;
  429. PROCEDURE PackBoolTags    *{base,- 42}(initialFlags{0}: LONGSET;
  430.                                        taga{8}        : TagListPtr;
  431.                                        boolMap{9}     : ARRAY OF TagItem): LONGSET;
  432. PROCEDURE NextTagItem     *{base,- 48}(VAR tagListPtr{8}: TagItemPtr): TagItemPtr;
  433. PROCEDURE FilterTagChanges*{base,- 54}(changeList{8}  : ARRAY OF TagItem;
  434.                                        originalList{9}: ARRAY OF TagItem;
  435.                                        apply{0}       : BOOLEAN);
  436. PROCEDURE MapTags         *{base,- 60}(tagList{8}     : ARRAY OF TagItem;
  437.                                        mapList{9}     : ARRAY OF TagItem;
  438.                                        mapType{0}     : LONGINT);
  439. PROCEDURE AllocateTagItems*{base,- 66}(numTags{0}     : LONGINT): TagListPtr;
  440. PROCEDURE CloneTagItemsA  *{base,- 72}(tagList{8}     : ARRAY OF TagItem): TagListPtr;
  441. PROCEDURE CloneTagItems   *{base,- 72}(taga{8}        : TagListPtr): TagListPtr;
  442. PROCEDURE FreeTagItems    *{base,- 78}(tagList{8}     : TagListPtr);
  443. PROCEDURE RefreshTagItemClones*{base,- 84}(clone{8}   : ARRAY OF TagItem;
  444.                                        original{9}    : ARRAY OF TagItem);
  445. PROCEDURE TagInArray      *{base,- 90}(tagValue{0}    : TagID;
  446.                                        tagArray{8}    : ARRAY OF TagID): BOOLEAN;
  447. PROCEDURE FilterTagItems  *{base,- 96}(tagList{8}     : ARRAY OF TagItem;
  448.                                        filterArray{9} : ARRAY OF TagID;
  449.                                        logic{0}       : LONGINT): LONGINT;
  450.  
  451. (* HOOK FUNCTIONS *)
  452.  
  453. PROCEDURE CallHookPkt     *{base,-102}(hook{8}        : HookPtr;
  454.                                        object{10}     : e.ADDRESS;
  455.                                        paramPacket{9} : e.ADDRESS): LONGINT;
  456.  
  457. (* DATE FUNCTIONS *)
  458.  
  459. PROCEDURE Amiga2Date      *{base,-120}(seconds{0}     : LONGINT;
  460.                                        VAR date{8}    : ClockData);
  461. PROCEDURE Date2Amiga      *{base,-126}(VAR date{8}    : ClockData): LONGINT;
  462. PROCEDURE CheckDate       *{base,-132}(VAR date{8}    : ClockData): LONGINT;
  463.  
  464. (* 32 bit integer muliply functions *)
  465.  
  466. PROCEDURE SMult32         *{base,-138}(factor1{0},  factor2{1} : LONGINT): LONGINT;
  467. PROCEDURE UMult32         *{base,-144}(factor1{0},  factor2{1} : LONGINT): LONGINT;
  468.  
  469. (* 32 bit integer division funtions. The quotient and the remainder are *)
  470. (* returned respectively in d0 and d1 *)
  471.  
  472. PROCEDURE SDivMod32       *{base,-150}(dividend{0}, divisor{1} : LONGINT): LONGINT;
  473. PROCEDURE UDivMod32       *{base,-156}(dividend{0}, divisor{1} : LONGINT): LONGINT;
  474.  
  475. (*--- functions in V37 or higher (Release 2.04) ---*)
  476.  
  477. (* International string routines *)
  478.  
  479. PROCEDURE Stricmp         *{base,-162}(string1{8}: ARRAY OF CHAR;
  480.                                        string2{9}: ARRAY OF CHAR): LONGINT;
  481. PROCEDURE Strnicmp        *{base,-168}(string1{8}: ARRAY OF CHAR;
  482.                                        string2{9}: ARRAY OF CHAR;
  483.                                        length{0}: LONGINT): LONGINT;
  484. PROCEDURE ToUpper         *{base,-174}(character{0}: CHAR): CHAR;
  485. PROCEDURE ToLower         *{base,-180}(character{0}: CHAR): CHAR;
  486.  
  487. (*--- functions in V39 or higher (Release 3) ---*)
  488.  
  489. (* More tag Item functions *)
  490.  
  491. PROCEDURE ApplyTagChangesA*{base,-0BAH}(list{8}          : ARRAY OF TagItem;
  492.                                         changeList{9}    : ARRAY OF TagItem);
  493. PROCEDURE ApplyTagChanges *{base,-0BAH}(list{8}          : ARRAY OF TagItem;
  494.                                         changeList{9}    : TagListPtr);
  495.  
  496. (* 64 bit integer muliply functions. The results are 64 bit quantities *)
  497. (* returned in D0 and D1 *)
  498.  
  499. PROCEDURE SMult64         *{base,-0C6H}(arg1{0}: LONGINT; arg2{1}: LONGINT): LONGINT;
  500. PROCEDURE UMult64         *{base,-0CCH}(arg1{0}: LONGINT; arg2{1}: LONGINT): LONGINT;
  501.  
  502. (* Structure to Tag and Tag to Structure support routines *)
  503.  
  504. PROCEDURE PackStructureTagsA  *{base,-0D2H}(pack{8}      : e.APTR;
  505.                                             packTable{9} : ARRAY OF LONGINT;
  506.                                             tagList{10}  : ARRAY OF TagItem): LONGINT;
  507. PROCEDURE PackStructureTags   *{base,-0D2H}(pack{8}      : e.APTR;
  508.                                             packTable{9} : ARRAY OF LONGINT;
  509.                                             tagList{10}  : TagListPtr): LONGINT;
  510. PROCEDURE UnpackStructureTagsA*{base,-0D8H}(pack{8}      : Tag;
  511.                                             packTable{9} : ARRAY OF LONGINT;
  512.                                             tagList{10}  : ARRAY OF TagItem): LONGINT;
  513. PROCEDURE UnpackStructureTags *{base,-0D8H}(pack{8}      : e.APTR;
  514.                                             packTable{9} : ARRAY OF LONGINT;
  515.                                             tagList{10}  : TagListPtr): LONGINT;
  516.  
  517. (* New, object-oriented NameSpaces *)
  518.  
  519. PROCEDURE AddNamedObject  *{base,-0DEH}(nameSpace{8}   : NamedObjectPtr;
  520.                                         object{9}      : NamedObjectPtr): BOOLEAN;
  521. PROCEDURE AllocNamedObjectA *{base,-0E4H}(name{8}      : ARRAY OF CHAR;
  522.                                           tagList{9}   : ARRAY OF TagItem): NamedObjectPtr;
  523. PROCEDURE AllocNamedObject  *{base,-0E4H}(name{8}      : ARRAY OF CHAR;
  524.                                           tag1{9}..    : Tag): NamedObjectPtr;
  525. PROCEDURE AttemptRemNamedObject*{base,-0EAH}( object{8}: NamedObjectPtr): BOOLEAN;
  526. PROCEDURE FindNamedObject  *{base,-0F0H}(nameSpace{8}  : NamedObjectPtr;
  527.                                          name{9}       : ARRAY OF CHAR;
  528.                                          lastObject{10}: NamedObjectPtr): NamedObjectPtr;
  529. PROCEDURE FreeNamedObject *{base,-0F6H}(object{8}      : NamedObjectPtr);
  530. PROCEDURE NamedObjectName *{base,-0FCH}(object{8}      : NamedObjectPtr): e.LSTRPTR;
  531. PROCEDURE ReleaseNamedObject*{base,-102H}(object{8}    : NamedObjectPtr);
  532. PROCEDURE RemNamedObject  *{base,-108H}(object{8}      : NamedObjectPtr;
  533.                                         message{9}     : e.MessagePtr);
  534.  
  535. (* Unique ID generator *)
  536.  
  537. PROCEDURE GetUniqueID     *{base,-10EH}(): LONGINT;
  538.  
  539.  
  540. (*---- usefull procedures ---- *)
  541.  
  542. PROCEDURE IgnoreIfNIL * (tagVal{0}: TagID; data{1}: Tag): TagID;
  543. BEGIN
  544.   IF data # NIL THEN RETURN tagVal ELSE RETURN ignore END;
  545. END IgnoreIfNIL;
  546.  
  547. PROCEDURE Bool2Long * (b{0}: BOOLAN): e.LONGBOOL;
  548. BEGIN
  549.   IF b THEN RETURN e.LTRUE ELSE RETURN e.LFALSE; END;
  550. END Bool2Long;
  551.  
  552. PROCEDURE Long2Bool * (value{0} LONGINT): BOOLEAN);
  553. BEGIN
  554.   RETURN value # e.LFALSE;
  555. END Long2Bool;
  556.  
  557. BEGIN
  558.   base :=  e.OpenLibrary(utilityName,37);
  559. CLOSE
  560.   IF base#NIL THEN e.CloseLibrary(base) END;
  561.  
  562. END Utility.
  563.  
  564.